﻿// Autore: Mattia Barrasso

using System.Linq;
using NUnit.Framework;
using RecipesManager.Data;
using TechTalk.SpecFlow;
using White.Core.UIItems;

namespace RecipesManager.Specs.Ospite
{
    [Binding, Scope(Feature = "RimuoviOspite")]
    public class RimuoviOspiteSteps : OspiteBdd
    {
        Button _confirm;
        Button _cancel;
        Button _accept;

        void GetConfirmDialogUi()
        {
            _confirm = MainWindow.Get<Button>("6");
            _cancel = MainWindow.Get<Button>("7");
        }

        void GetAcceptDialogUi()
        {
            _accept = MainWindow.Get<Button>("2");
        }

        [BeforeScenario]
        public new void SetUpScenario()
        {
            base.SetUpScenario();
        }

        [AfterScenario]
        public new void TearDownScenario()
        {
            base.TearDownScenario();
        }

        [Given(Regex = "esiste l'ospite \"([a-zA-Z ]+)\"")]
        public void DatoEsisteOspite(string ospite)
        {
            Manager.Guests.Add(ospite);
        }

        [Given(Regex = "non esiste l'ospite \"([a-zA-Z ]+)\"")]
        public void DatoNonEsisteOspite(string ospite)
        {
            Assert.That(!Manager.Guests.Contains(ospite));
        }

        [Given(Regex = "esiste l'evento \"([a-zA-Z ]+)\"")]
        public void DatoEsisteEvento(string evento)
        {
            var id = Manager.Events.Add(evento).Id;
            Eventi.Add(evento, id);
        }

        [Given(Regex = "l'ospite \"([a-zA-Z ]+)\" è invitato all'evento \"([a-zA-Z ]+)\"")]
        public void DatoOspiteInvitato(string ospite, string evento)
        {
            var id = Eventi[evento];
            Assert.That(Manager.Events.Contains(id));
            Manager.Events[id].Guests.Add(ospite);
        }

        [Given(Regex = "\"([a-zA-Z ]+)\" ha una preferenza verso \"([a-zA-Z ]+)\", valore: ([0-9]+)")]
        public void DataPreferenzaFraOspiti(string ospite, string ospitePreferito, int valore)
        {
            var guestRating = GuestRating.Neuter;
            if(valore == 0)
            {
                guestRating = GuestRating.VeryGood;
            }else
            {
                Assert.Fail();
            }
            Manager.Guests[ospite].GuestRatings.Add(ospitePreferito, guestRating);
        }

        [Given(Regex = "\"([a-zA-Z ]+)\" ha una relazione con \"([a-zA-Z ]+)\"")]
        public void DatoRelazioneFraOspiti(string ospite, string ospiteInRelazione)
        {
            Manager.Guests[ospite].GuestRelationships.Add(ospiteInRelazione);
        }

        [Given(Regex = "seleziono l'ospite \"([a-zA-Z ]+)\"")]
        public void DatoSelezionoOspite(string ospite)
        {
            NavigateToGuests();
            GetGuestsUi();
            Assert.That(Guests.Items.Exists(item => item.Text.Equals(ospite)));
            Guests.Items.Select(ospite);
        }

        [When(Regex = "elimino l'ospite")]
        public void QuandoElimino()
        {
            RemoveGuest.Click();
        }

        [When(Regex = "confermo")]
        public void QuandoConfermo()
        {
            GetConfirmDialogUi();
            _confirm.Click();
            Assert.That(!MainWindow.ModalWindows().Any());
        }

        [When(Regex = "annullo")]
        public void QuandoAnnullo()
        {
            GetConfirmDialogUi();
            _cancel.Click();
            Assert.That(!MainWindow.ModalWindows().Any());
        }

        [When(Regex = "accetto")]
        public void QuandoAccetto()
        {
            GetAcceptDialogUi();
            _accept.Click();
            Assert.That(!MainWindow.ModalWindows().Any());
        }

        [Then(Regex = "appare un messaggio")]
        public void AlloraSuccesso()
        {
            Assert.That(MainWindow.ModalWindows().Count() == 1);
        }

        [Then(Regex = "esiste l'ospite \"([a-zA-Z ]+)\"")]
        public void AlloraEsisteOspite(string ospite)
        {
            Assert.That(Guests.Items.Exists(item => item.Text.Equals(ospite)));
            Assert.That(Manager.Guests.Contains(ospite));
        }

        [Then(Regex = "non esiste l'ospite \"([a-zA-Z ]+)\"")]
        public void AlloraNonEsisteOspite(string ospite)
        {
            Assert.That(!Guests.Items.Exists(item => item.Text.Equals(ospite)));
            //NavigateToMainMenu();
            Assert.That(!Manager.Guests.Contains(ospite));
        }
    }
}
